{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "\n",
    "sys.path.append(\"..\")\n",
    "sys.path.append(\"../..\")\n",
    "\n",
    "import numpy as np \n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Occupancy data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## [from examples/examples.py]\n",
    "from download import download_all \n",
    "\n",
    "## The path to the test data sets\n",
    "FIXTURES  = os.path.join(os.getcwd(), \"data\")\n",
    "\n",
    "## Dataset loading mechanisms\n",
    "datasets = {\n",
    "    \"credit\": os.path.join(FIXTURES, \"credit\", \"credit.csv\"),\n",
    "    \"concrete\": os.path.join(FIXTURES, \"concrete\", \"concrete.csv\"),\n",
    "    \"occupancy\": os.path.join(FIXTURES, \"occupancy\", \"occupancy.csv\"),\n",
    "    \"mushroom\": os.path.join(FIXTURES, \"mushroom\", \"mushroom.csv\"),\n",
    "}\n",
    "\n",
    "def load_data(name, download=True):\n",
    "    \"\"\"\n",
    "    Loads and wrangles the passed in dataset by name.\n",
    "    If download is specified, this method will download any missing files. \n",
    "    \"\"\"\n",
    "    # Get the path from the datasets \n",
    "    path = datasets[name]\n",
    "    \n",
    "    # Check if the data exists, otherwise download or raise \n",
    "    if not os.path.exists(path):\n",
    "        if download:\n",
    "            download_all() \n",
    "        else:\n",
    "            raise ValueError((\n",
    "                \"'{}' dataset has not been downloaded, \"\n",
    "                \"use the download.py module to fetch datasets\"\n",
    "            ).format(name))\n",
    "    \n",
    "    # Return the data frame\n",
    "    return pd.read_csv(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20560\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>temperature</th>\n",
       "      <th>relative humidity</th>\n",
       "      <th>light</th>\n",
       "      <th>C02</th>\n",
       "      <th>humidity</th>\n",
       "      <th>occupancy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-02-04 17:51:00</td>\n",
       "      <td>23.18</td>\n",
       "      <td>27.2720</td>\n",
       "      <td>426.0</td>\n",
       "      <td>721.25</td>\n",
       "      <td>0.004793</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-02-04 17:51:59</td>\n",
       "      <td>23.15</td>\n",
       "      <td>27.2675</td>\n",
       "      <td>429.5</td>\n",
       "      <td>714.00</td>\n",
       "      <td>0.004783</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2015-02-04 17:53:00</td>\n",
       "      <td>23.15</td>\n",
       "      <td>27.2450</td>\n",
       "      <td>426.0</td>\n",
       "      <td>713.50</td>\n",
       "      <td>0.004779</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2015-02-04 17:54:00</td>\n",
       "      <td>23.15</td>\n",
       "      <td>27.2000</td>\n",
       "      <td>426.0</td>\n",
       "      <td>708.25</td>\n",
       "      <td>0.004772</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015-02-04 17:55:00</td>\n",
       "      <td>23.10</td>\n",
       "      <td>27.2000</td>\n",
       "      <td>426.0</td>\n",
       "      <td>704.50</td>\n",
       "      <td>0.004757</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              datetime  temperature  relative humidity  light     C02  \\\n",
       "0  2015-02-04 17:51:00        23.18            27.2720  426.0  721.25   \n",
       "1  2015-02-04 17:51:59        23.15            27.2675  429.5  714.00   \n",
       "2  2015-02-04 17:53:00        23.15            27.2450  426.0  713.50   \n",
       "3  2015-02-04 17:54:00        23.15            27.2000  426.0  708.25   \n",
       "4  2015-02-04 17:55:00        23.10            27.2000  426.0  704.50   \n",
       "\n",
       "   humidity  occupancy  \n",
       "0  0.004793          1  \n",
       "1  0.004783          1  \n",
       "2  0.004779          1  \n",
       "3  0.004772          1  \n",
       "4  0.004757          1  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the classification data set\n",
    "data = load_data('occupancy') \n",
    "print(len(data))\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the features of interest and the classes of the target \n",
    "features = [\"temperature\", \"relative humidity\", \"light\", \"C02\", \"humidity\"]\n",
    "classes = ['unoccupied', 'occupied']\n",
    "\n",
    "# Searching the whole dataset takes a while (15 mins on my mac)... \n",
    "# For demo purposes, we reduce the size\n",
    "X = data[features].head(2000)\n",
    "y = data.occupancy.head(2000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameter projection\n",
    "\n",
    "* Because the visualizer only displays results across two parameters, we need some way of reducing the dimension to 2. \n",
    "* Our approach: for each value of the parameters of interest, display the _maximum_ score across all the other parameters.\n",
    "\n",
    "Here we demo the `param_projection` utility function that does this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/pschafer/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "from yellowbrick.gridsearch.base import param_projection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit a vanilla grid search... these are the example parameters from sklearn's gridsearch docs.\n",
    "svc = SVC()\n",
    "grid = [{'kernel': ['rbf'], 'gamma': [1e-3, 1e-4], 'C': [1, 10, 100, 1000]},\n",
    "        {'kernel': ['linear'], 'C': [1, 10, 100, 1000]}]\n",
    "gs = GridSearchCV(svc, grid, n_jobs=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 147 ms, sys: 28.2 ms, total: 175 ms\n",
      "Wall time: 31 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=None, error_score='raise',\n",
       "       estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n",
       "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False),\n",
       "       fit_params=None, iid=True, n_jobs=4,\n",
       "       param_grid=[{'kernel': ['rbf'], 'gamma': [0.001, 0.0001], 'C': [1, 10, 100, 1000]}, {'kernel': ['linear'], 'C': [1, 10, 100, 1000]}],\n",
       "       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n",
       "       scoring=None, verbose=0)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "gs.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As of Scikit-learn 0.18, `cv_results` has replaced `grid_scores` as the grid search results format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/pschafer/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('mean_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "/Users/pschafer/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('split0_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "/Users/pschafer/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('split1_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "/Users/pschafer/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('split2_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "/Users/pschafer/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('std_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'mean_fit_time': array([0.02446747, 0.01360734, 0.02218564, 0.00889039, 0.02143168,\n",
       "        0.0146842 , 0.03453048, 0.02234364, 1.94032502, 3.24313124,\n",
       "        4.1275959 , 3.99856925]),\n",
       " 'mean_score_time': array([0.00456238, 0.00284052, 0.00362539, 0.00334334, 0.00262896,\n",
       "        0.00233173, 0.00262411, 0.00177709, 0.0011073 , 0.00116841,\n",
       "        0.00101606, 0.00154575]),\n",
       " 'mean_test_score': array([0.895 , 0.891 , 0.9055, 0.8995, 0.8995, 0.914 , 0.9045, 0.9185,\n",
       "        0.915 , 0.9135, 0.9105, 0.9115]),\n",
       " 'mean_train_score': array([0.9847535 , 0.97950518, 0.990002  , 0.98125506, 0.99450106,\n",
       "        0.98475368, 0.99625056, 0.99275119, 0.96525668, 0.96550693,\n",
       "        0.96525687, 0.96500699]),\n",
       " 'param_C': masked_array(data=[1, 1, 10, 10, 100, 100, 1000, 1000, 1, 10, 100, 1000],\n",
       "              mask=[False, False, False, False, False, False, False, False,\n",
       "                    False, False, False, False],\n",
       "        fill_value='?',\n",
       "             dtype=object),\n",
       " 'param_gamma': masked_array(data=[0.001, 0.0001, 0.001, 0.0001, 0.001, 0.0001, 0.001,\n",
       "                    0.0001, --, --, --, --],\n",
       "              mask=[False, False, False, False, False, False, False, False,\n",
       "                     True,  True,  True,  True],\n",
       "        fill_value='?',\n",
       "             dtype=object),\n",
       " 'param_kernel': masked_array(data=['rbf', 'rbf', 'rbf', 'rbf', 'rbf', 'rbf', 'rbf', 'rbf',\n",
       "                    'linear', 'linear', 'linear', 'linear'],\n",
       "              mask=[False, False, False, False, False, False, False, False,\n",
       "                    False, False, False, False],\n",
       "        fill_value='?',\n",
       "             dtype=object),\n",
       " 'params': [{'C': 1, 'gamma': 0.001, 'kernel': 'rbf'},\n",
       "  {'C': 1, 'gamma': 0.0001, 'kernel': 'rbf'},\n",
       "  {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'},\n",
       "  {'C': 10, 'gamma': 0.0001, 'kernel': 'rbf'},\n",
       "  {'C': 100, 'gamma': 0.001, 'kernel': 'rbf'},\n",
       "  {'C': 100, 'gamma': 0.0001, 'kernel': 'rbf'},\n",
       "  {'C': 1000, 'gamma': 0.001, 'kernel': 'rbf'},\n",
       "  {'C': 1000, 'gamma': 0.0001, 'kernel': 'rbf'},\n",
       "  {'C': 1, 'kernel': 'linear'},\n",
       "  {'C': 10, 'kernel': 'linear'},\n",
       "  {'C': 100, 'kernel': 'linear'},\n",
       "  {'C': 1000, 'kernel': 'linear'}],\n",
       " 'rank_test_score': array([11, 12,  7,  9,  9,  3,  8,  1,  2,  4,  6,  5], dtype=int32),\n",
       " 'split0_test_score': array([0.85907046, 0.82158921, 0.89805097, 0.84557721, 0.87256372,\n",
       "        0.88905547, 0.89655172, 0.90254873, 0.91004498, 0.93103448,\n",
       "        0.90854573, 0.91754123]),\n",
       " 'split0_train_score': array([0.98349587, 0.97974494, 0.987997  , 0.98274569, 0.99324831,\n",
       "        0.98424606, 0.99474869, 0.99024756, 0.95723931, 0.95873968,\n",
       "        0.9579895 , 0.9579895 ]),\n",
       " 'split1_test_score': array([0.82608696, 0.85307346, 0.82608696, 0.85307346, 0.82608696,\n",
       "        0.85307346, 0.82608696, 0.85307346, 0.89055472, 0.89055472,\n",
       "        0.89055472, 0.89055472]),\n",
       " 'split1_train_score': array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]),\n",
       " 'split2_test_score': array([1.        , 0.9984985 , 0.99249249, 1.        , 1.        ,\n",
       "        1.        , 0.99099099, 1.        , 0.94444444, 0.91891892,\n",
       "        0.93243243, 0.92642643]),\n",
       " 'split2_train_score': array([0.97076462, 0.95877061, 0.982009  , 0.96101949, 0.99025487,\n",
       "        0.97001499, 0.994003  , 0.988006  , 0.93853073, 0.93778111,\n",
       "        0.93778111, 0.93703148]),\n",
       " 'std_fit_time': array([0.00783314, 0.00750969, 0.00391411, 0.00338101, 0.0082266 ,\n",
       "        0.00776113, 0.02039378, 0.01587166, 1.54496874, 2.5505148 ,\n",
       "        2.94695329, 2.82673379]),\n",
       " 'std_score_time': array([1.04638701e-03, 1.01035138e-03, 1.00287903e-03, 2.10844017e-03,\n",
       "        5.38548407e-04, 6.35982442e-04, 6.02011534e-04, 5.75618900e-04,\n",
       "        2.99961800e-04, 8.37446367e-05, 3.58759960e-04, 6.80733055e-04]),\n",
       " 'std_test_score': array([0.07540321, 0.07703631, 0.06813033, 0.07107689, 0.07350339,\n",
       "        0.06251678, 0.06754775, 0.06102718, 0.02227512, 0.01696758,\n",
       "        0.01715017, 0.01525357]),\n",
       " 'std_train_score': array([0.01196838, 0.01683268, 0.00748038, 0.01594859, 0.00407586,\n",
       "        0.01224659, 0.00266867, 0.00520673, 0.02572711, 0.02584756,\n",
       "        0.02591536, 0.02618132])}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs.cv_results_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Demo the use of param_projection... It identifies the unique values of the the two parameter values and gets the best score for each (here taking the max over `gamma` values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 10, 100, 1000],\n",
       " ['linear', 'rbf'],\n",
       " array([[0.915 , 0.9135, 0.9105, 0.9115],\n",
       "        [0.895 , 0.9055, 0.914 , 0.9185]]))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param_1 = 'C'\n",
    "param_2 = 'kernel'\n",
    "param_1_vals, param2_vals, best_scores = param_projection(gs.cv_results_, param_1, param_2)\n",
    "param_1_vals, param2_vals, best_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GridSearchColorPlot\n",
    "\n",
    "This visualizer wraps the GridSearchCV object and plots the values obtained from `param_projection`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from yellowbrick.gridsearch import GridSearchColorPlot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1105565f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'C', 'kernel')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10f5c7208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'kernel', 'C')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11054eb00>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'C', 'gamma')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If there are missing values in the grid, these are filled with a hatch (see https://stackoverflow.com/a/35905483/7637679)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10d102a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'kernel', 'gamma')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Choose a different metric..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x108bb6ba8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'C', 'kernel', metric='mean_fit_time')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quick Method\n",
    "\n",
    "Because grid search can take a long time and we may want to interactively cut the results a few different ways, by default the quick method assumes that the GridSearchCV object is **already fit** if no X data is passed in. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from yellowbrick.gridsearch import gridsearch_color_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 84.1 ms, sys: 2.95 ms, total: 87.1 ms\n",
      "Wall time: 87.4 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1105f2ef0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x110649d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "# passing the GridSearchCV object pre-fit\n",
    "gridsearch_color_plot(gs, 'C', 'kernel')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 73.3 ms, sys: 3.95 ms, total: 77.2 ms\n",
      "Wall time: 79.8 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1107c5470>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10e2d6cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "# trying a different cut across parameters\n",
    "gridsearch_color_plot(gs, 'C', 'gamma')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 206 ms, sys: 35.1 ms, total: 241 ms\n",
      "Wall time: 31 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1107c5710>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1109274a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "# When we provide X, the `fit` method will call fit (takes longer)\n",
    "gridsearch_color_plot(gs, 'C', 'kernel', X=X, y=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 67.5 ms, sys: 3.4 ms, total: 70.9 ms\n",
      "Wall time: 77.7 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x110a26208>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x110a6e4e0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "# can also choose a different metric\n",
    "gridsearch_color_plot(gs, 'C', 'kernel', metric='mean_fit_time')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameter errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bad param values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "YellowbrickKeyError",
     "evalue": "\"Parameter 'foo' does not exist in the grid search results\"",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(cv_results, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m     57\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 58\u001b[0;31m         \u001b[0mx_vals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcv_results\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'param_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     59\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/utils/deprecation.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m    122\u001b[0m             \u001b[0mwarnings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mwarn_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mwarn_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 123\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDeprecationDict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 'param_foo'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mYellowbrickKeyError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-5a2e9521b555>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'foo'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m    187\u001b[0m         \"\"\"\n\u001b[1;32m    188\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    190\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/pcolor.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    138\u001b[0m         \u001b[0;31m# Project the grid search results to 2 dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    139\u001b[0m         x_vals, y_vals, best_scores = self.param_projection(\n\u001b[0;32m--> 140\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    141\u001b[0m         )\n\u001b[1;32m    142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(self, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m    162\u001b[0m             \u001b[0mArray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mscores\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdisplayed\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0meach\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0mpair\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    163\u001b[0m         \"\"\"\n\u001b[0;32m--> 164\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mparam_projection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    165\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    166\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(cv_results, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m     59\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     60\u001b[0m         raise YellowbrickKeyError(\"Parameter '{}' does not exist in the grid \"\n\u001b[0;32m---> 61\u001b[0;31m                                   \"search results\".format(x_param))\n\u001b[0m\u001b[1;32m     62\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     63\u001b[0m         \u001b[0my_vals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcv_results\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'param_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mYellowbrickKeyError\u001b[0m: \"Parameter 'foo' does not exist in the grid search results\""
     ]
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'foo', 'kernel')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "YellowbrickKeyError",
     "evalue": "\"Parameter 'foo' does not exist in the grid search results\"",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(cv_results, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m     62\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m         \u001b[0my_vals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcv_results\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'param_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     64\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/utils/deprecation.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m    122\u001b[0m             \u001b[0mwarnings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mwarn_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mwarn_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 123\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDeprecationDict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 'param_foo'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mYellowbrickKeyError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-1cfe8afcafe9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'foo'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m    187\u001b[0m         \"\"\"\n\u001b[1;32m    188\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    190\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/pcolor.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    138\u001b[0m         \u001b[0;31m# Project the grid search results to 2 dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    139\u001b[0m         x_vals, y_vals, best_scores = self.param_projection(\n\u001b[0;32m--> 140\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    141\u001b[0m         )\n\u001b[1;32m    142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(self, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m    162\u001b[0m             \u001b[0mArray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mscores\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdisplayed\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0meach\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0mpair\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    163\u001b[0m         \"\"\"\n\u001b[0;32m--> 164\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mparam_projection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    165\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    166\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(cv_results, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m     64\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m         raise YellowbrickKeyError(\"Parameter '{}' does not exist in the grid \"\n\u001b[0;32m---> 66\u001b[0;31m                                   \"search results\".format(y_param))\n\u001b[0m\u001b[1;32m     67\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     68\u001b[0m         \u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcv_results\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mYellowbrickKeyError\u001b[0m: \"Parameter 'foo' does not exist in the grid search results\""
     ]
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'C', 'foo')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bad metric option"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "YellowbrickKeyError",
     "evalue": "\"Metric 'foo' does not exist in the grid search results\"",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(cv_results, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m     67\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m         \u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcv_results\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     69\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.pyenv/versions/3.6.2/envs/yellowbrick/lib/python3.6/site-packages/sklearn/utils/deprecation.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m    122\u001b[0m             \u001b[0mwarnings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mwarn_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mwarn_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 123\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDeprecationDict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 'foo'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mYellowbrickKeyError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-d60beabdd754>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'foo'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m    187\u001b[0m         \"\"\"\n\u001b[1;32m    188\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    190\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/pcolor.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    138\u001b[0m         \u001b[0;31m# Project the grid search results to 2 dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    139\u001b[0m         x_vals, y_vals, best_scores = self.param_projection(\n\u001b[0;32m--> 140\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    141\u001b[0m         )\n\u001b[1;32m    142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(self, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m    162\u001b[0m             \u001b[0mArray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mscores\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdisplayed\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0meach\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0mpair\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    163\u001b[0m         \"\"\"\n\u001b[0;32m--> 164\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mparam_projection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    165\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    166\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(cv_results, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     70\u001b[0m         raise YellowbrickKeyError(\"Metric '{}' does not exist in the grid \"\n\u001b[0;32m---> 71\u001b[0;31m                                   \"search results\".format(metric))\n\u001b[0m\u001b[1;32m     72\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     73\u001b[0m     \u001b[0;31m# Get unique, unmasked values of the two display parameters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mYellowbrickKeyError\u001b[0m: \"Metric 'foo' does not exist in the grid search results\""
     ]
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'C', 'kernel', metric='foo')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metric option exists in cv_results but is not numeric -> not valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "YellowbrickValueError",
     "evalue": "Cannot display grid search results for metric 'param_kernel': result values may not all be numeric",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(cv_results, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m    104\u001b[0m                 \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 105\u001b[0;31m                     \u001b[0mbest_scores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mall_scores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    106\u001b[0m                 \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'linear'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mYellowbrickValueError\u001b[0m                     Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-25-8c5aa43d422c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'param_kernel'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m    187\u001b[0m         \"\"\"\n\u001b[1;32m    188\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    190\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/pcolor.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    138\u001b[0m         \u001b[0;31m# Project the grid search results to 2 dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    139\u001b[0m         x_vals, y_vals, best_scores = self.param_projection(\n\u001b[0;32m--> 140\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    141\u001b[0m         )\n\u001b[1;32m    142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(self, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m    162\u001b[0m             \u001b[0mArray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mscores\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdisplayed\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0meach\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0mpair\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    163\u001b[0m         \"\"\"\n\u001b[0;32m--> 164\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mparam_projection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    165\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    166\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(cv_results, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m    107\u001b[0m                     raise YellowbrickValueError(\n\u001b[1;32m    108\u001b[0m                         \u001b[0;34m\"Cannot display grid search results for metric '{}': \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 109\u001b[0;31m                         \u001b[0;34m\"result values may not all be numeric\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    110\u001b[0m                     )\n\u001b[1;32m    111\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mYellowbrickValueError\u001b[0m: Cannot display grid search results for metric 'param_kernel': result values may not all be numeric"
     ]
    }
   ],
   "source": [
    "gs_viz = GridSearchColorPlot(gs, 'C', 'kernel', metric='param_kernel')\n",
    "gs_viz.fit(X, y).poof()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
